package com.bailian.system.utils;

import java.util.List;
import java.util.stream.Collectors;
import com.bailian.system.domain.BlPark;
import com.bailian.system.domain.BlParkTags;
import com.bailian.system.domain.BlWarehouseType;
import com.bailian.system.domain.BlParkConfig;
import com.bailian.system.domain.BlParkService;

/**
 * 园区查询工具类
 * 
 * @author bailian
 * @date 2025-08-04
 */
public class ParkQueryUtils {
    
    /**
     * 根据标签名称精确匹配园区
     * 
     * @param parks 园区列表
     * @param tagName 标签名称
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByTagName(List<BlPark> parks, String tagName) {
        if (tagName == null || tagName.trim().isEmpty()) {
            return parks;
        }
        
        return parks.stream()
            .filter(park -> {
                if (park.getParkTags() == null) {
                    return false;
                }
                return park.getParkTags().stream()
                    .anyMatch(tag -> tagName.equalsIgnoreCase(tag.getTagName()));
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据仓库类型名称精确匹配园区
     * 
     * @param parks 园区列表
     * @param typeName 仓库类型名称
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByWarehouseTypeName(List<BlPark> parks, String typeName) {
        if (typeName == null || typeName.trim().isEmpty()) {
            return parks;
        }
        
        return parks.stream()
            .filter(park -> {
                if (park.getWarehouseTypes() == null) {
                    return false;
                }
                return park.getWarehouseTypes().stream()
                    .anyMatch(type -> typeName.equalsIgnoreCase(type.getTypeName()));
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据硬件配置名称精确匹配园区
     * 
     * @param parks 园区列表
     * @param configName 硬件配置名称
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByHardwareConfigName(List<BlPark> parks, String configName) {
        if (configName == null || configName.trim().isEmpty()) {
            return parks;
        }
        
        return parks.stream()
            .filter(park -> {
                if (park.getHardwareConfig() == null) {
                    return false;
                }
                return park.getHardwareConfig().stream()
                    .anyMatch(config -> configName.equalsIgnoreCase(config.getConfigName()));
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据服务名称精确匹配园区
     * 
     * @param parks 园区列表
     * @param serviceName 服务名称
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByServiceName(List<BlPark> parks, String serviceName) {
        if (serviceName == null || serviceName.trim().isEmpty()) {
            return parks;
        }
        
        return parks.stream()
            .filter(park -> {
                if (park.getParkServices() == null) {
                    return false;
                }
                return park.getParkServices().stream()
                    .anyMatch(service -> serviceName.equalsIgnoreCase(service.getServiceName()));
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据价格范围过滤园区
     * 
     * @param parks 园区列表
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByPriceRange(List<BlPark> parks, Double minPrice, Double maxPrice) {
        return parks.stream()
            .filter(park -> {
                if (park.getRentalPrice() == null) {
                    return false;
                }
                double price = park.getRentalPrice().doubleValue();
                if (minPrice != null && price < minPrice) {
                    return false;
                }
                if (maxPrice != null && price > maxPrice) {
                    return false;
                }
                return true;
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据面积范围过滤园区
     * 
     * @param parks 园区列表
     * @param minArea 最小面积
     * @param maxArea 最大面积
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByAreaRange(List<BlPark> parks, Double minArea, Double maxArea) {
        return parks.stream()
            .filter(park -> {
                if (park.getTotalArea() == null) {
                    return false;
                }
                double area = park.getTotalArea().doubleValue();
                if (minArea != null && area < minArea) {
                    return false;
                }
                if (maxArea != null && area > maxArea) {
                    return false;
                }
                return true;
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 根据推荐状态过滤园区
     * 
     * @param parks 园区列表
     * @param isRecommend 推荐状态
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByRecommend(List<BlPark> parks, Integer isRecommend) {
        if (isRecommend == null) {
            return parks;
        }
        
        return parks.stream()
            .filter(park -> isRecommend.equals(park.getIsRecommend()))
            .collect(Collectors.toList());
    }
    
    /**
     * 多条件组合过滤园区
     * 
     * @param parks 园区列表
     * @param conditions 查询条件
     * @return 匹配的园区列表
     */
    public static List<BlPark> filterByConditions(List<BlPark> parks, BlPark conditions) {
        List<BlPark> result = parks;
        
        // 按园区名称过滤
        if (conditions.getParkName() != null && !conditions.getParkName().trim().isEmpty()) {
            result = result.stream()
                .filter(park -> park.getParkName() != null && 
                    park.getParkName().toLowerCase().contains(conditions.getParkName().toLowerCase()))
                .collect(Collectors.toList());
        }
        
        // 按地理位置过滤
        if (conditions.getLocation() != null && !conditions.getLocation().trim().isEmpty()) {
            result = result.stream()
                .filter(park -> park.getLocation() != null && 
                    park.getLocation().toLowerCase().contains(conditions.getLocation().toLowerCase()))
                .collect(Collectors.toList());
        }
        
        // 按推荐状态过滤
        if (conditions.getIsRecommend() != null) {
            result = filterByRecommend(result, conditions.getIsRecommend());
        }
        
        // 按面积过滤
        if (conditions.getTotalArea() != null) {
            result = filterByAreaRange(result, conditions.getTotalArea().doubleValue(), null);
        }
        
        // 按价格过滤
        if (conditions.getRentalPrice() != null) {
            result = filterByPriceRange(result, null, conditions.getRentalPrice().doubleValue());
        }
        
        return result;
    }
    
    /**
     * 搜索园区（支持多字段模糊查询）
     * 
     * @param parks 园区列表
     * @param keyword 搜索关键词
     * @return 匹配的园区列表
     */
    public static List<BlPark> searchParks(List<BlPark> parks, String keyword) {
        if (keyword == null || keyword.trim().isEmpty()) {
            return parks;
        }
        
        String lowerKeyword = keyword.toLowerCase();
        
        return parks.stream()
            .filter(park -> {
                // 搜索园区名称
                if (park.getParkName() != null && 
                    park.getParkName().toLowerCase().contains(lowerKeyword)) {
                    return true;
                }
                
                // 搜索园区描述
                if (park.getParkDescription() != null && 
                    park.getParkDescription().toLowerCase().contains(lowerKeyword)) {
                    return true;
                }
                
                // 搜索地理位置
                if (park.getLocation() != null && 
                    park.getLocation().toLowerCase().contains(lowerKeyword)) {
                    return true;
                }
                
                // 搜索管理人
                if (park.getManager() != null && 
                    park.getManager().toLowerCase().contains(lowerKeyword)) {
                    return true;
                }
                
                // 搜索标签
                if (park.getParkTags() != null) {
                    boolean hasTagMatch = park.getParkTags().stream()
                        .anyMatch(tag -> tag.getTagName() != null && 
                            tag.getTagName().toLowerCase().contains(lowerKeyword));
                    if (hasTagMatch) {
                        return true;
                    }
                }
                
                // 搜索仓库类型
                if (park.getWarehouseTypes() != null) {
                    boolean hasTypeMatch = park.getWarehouseTypes().stream()
                        .anyMatch(type -> type.getTypeName() != null && 
                            type.getTypeName().toLowerCase().contains(lowerKeyword));
                    if (hasTypeMatch) {
                        return true;
                    }
                }
                
                // 搜索硬件配置
                if (park.getHardwareConfig() != null) {
                    boolean hasConfigMatch = park.getHardwareConfig().stream()
                        .anyMatch(config -> config.getConfigName() != null && 
                            config.getConfigName().toLowerCase().contains(lowerKeyword));
                    if (hasConfigMatch) {
                        return true;
                    }
                }
                
                // 搜索园区服务
                if (park.getParkServices() != null) {
                    boolean hasServiceMatch = park.getParkServices().stream()
                        .anyMatch(service -> service.getServiceName() != null && 
                            service.getServiceName().toLowerCase().contains(lowerKeyword));
                    if (hasServiceMatch) {
                        return true;
                    }
                }
                
                return false;
            })
            .collect(Collectors.toList());
    }
} 